/**
 * loadingService.js
 * 提供医学影像查看器的加载流程控制功能
 * 从ViewerPage.vue中提取，专注于图像和序列加载流程的管理
 */

import * as viewerService from './viewerService';
import * as viewportService from './viewportService';

/**
 * 加载患者的所有检查
 * @param {string} patientId - 患者ID
 * @param {Object} context - 上下文对象，包含设置状态的回调
 * @returns {Promise<boolean>} 加载成功返回true
 */
export async function loadPatientStudies(patientId, context) {
  try {
    console.log('加载患者的所有检查:', patientId);
    
    // 设置加载状态
    if (context.setLoading) {
      context.setLoading(true);
    }
    
    // 调用viewerService获取检查列表
    const result = await viewerService.loadPatientStudies(patientId);
    
    if (result.success) {
      // 更新检查列表和当前选中的检查
      if (context.setStudyList) {
        context.setStudyList(result.studyList);
      }
      
      if (context.setActiveStudyId) {
        context.setActiveStudyId(result.activeStudyId);
      }
      
      // 加载选中的检查
      if (context.loadStudy) {
        await context.loadStudy(result.activeStudyId);
      }
      
      // 设置加载完成
      if (context.setLoading) {
        context.setLoading(false);
      }
      
      return true;
    } else {
      console.error(result.error);
      
      // 显示错误信息
      if (context.setError) {
        context.setError(result.error);
      }
      
      // 设置加载完成
      if (context.setLoading) {
        context.setLoading(false);
      }
      
      return false;
    }
  } catch (error) {
    console.error('加载患者检查失败:', error);
    
    // 显示错误信息
    if (context.setError) {
      context.setError(error.message || '加载患者检查失败');
    }
    
    // 设置加载完成
    if (context.setLoading) {
      context.setLoading(false);
    }
    
    return false;
  }
}

/**
 * 加载检查
 * @param {string} studyId - 检查ID
 * @param {Object} context - 上下文对象，包含设置状态的回调
 * @returns {Promise<boolean>} 加载成功返回true
 */
export async function loadStudy(studyId, context) {
  try {
    console.log('加载检查:', studyId);
    
    // 设置加载状态
    if (context.setLoading) {
      context.setLoading(true);
    }
    
    // 清空当前序列和图像
    if (context.resetData) {
      context.resetData();
    }
    
    // 记录这个检查为当前激活的检查
    if (context.setActiveStudyId) {
      context.setActiveStudyId(studyId);
    }
    
    // 调用viewerService获取序列列表
    const result = await viewerService.loadStudy(studyId);
    
    if (result.success) {
      // 更新序列列表和当前选中的序列
      if (context.setSeriesList) {
        context.setSeriesList(result.seriesList);
      }
      
      if (context.setActiveSeries) {
        context.setActiveSeries(result.activeSeries);
      }
      
      // 加载选中的序列
      if (context.loadSeries) {
        await context.loadSeries(result.activeSeries);
      }
      
      // 设置加载完成
      if (context.setLoading) {
        context.setLoading(false);
      }
      
      return true;
    } else {
      console.error(result.error);
      
      // 显示错误信息
      if (context.setError) {
        context.setError(result.error);
      }
      
      // 设置加载完成
      if (context.setLoading) {
        context.setLoading(false);
      }
      
      return false;
    }
  } catch (error) {
    console.error('加载检查失败:', error);
    
    // 显示错误信息
    if (context.setError) {
      context.setError(error.message || '加载检查失败');
    }
    
    // 设置加载完成
    if (context.setLoading) {
      context.setLoading(false);
    }
    
    return false;
  }
}

/**
 * 加载序列
 * @param {string} seriesId - 序列ID
 * @param {Object} series - 序列对象
 * @param {Object} context - 上下文对象，包含设置状态的回调
 * @returns {Promise<boolean>} 加载成功返回true
 */
export async function loadSeries(seriesId, series, context) {
  // 更新活动序列
  if (context.setActiveSeries) {
    context.setActiveSeries(seriesId);
  }
  
  if (!series) return false;
  
  // 设置加载状态
  if (context.setSeriesLoading) {
    context.setSeriesLoading(series, true);
  }
  
  try {
    // 调用viewerService获取图像ID列表
    const result = await viewerService.loadSeries(seriesId, series);
    
    if (result.success) {
      // 更新图像ID列表和总图像数量
      if (context.setImageIds) {
        context.setImageIds(result.imageIds);
      }
      
      if (context.setTotalImages) {
        context.setTotalImages(result.totalImages);
      }
      
      if (context.setCurrentImageIndex) {
        context.setCurrentImageIndex(0);
      }
      
      if (context.setSeriesDescription) {
        context.setSeriesDescription(result.currentSeriesDescription);
      }
      
      // 加载第一张图像并设置为缩略图
      try {
        if (context.loadAndDisplayImage && result.imageIds.length > 0) {
          console.log(`尝试加载第一张图像并创建缩略图: ${result.imageIds[0]}`);
          const firstImage = await context.loadAndDisplayImage(result.imageIds[0]);
          if (firstImage && context.createThumbnail) {
            console.log('第一张图像加载成功，创建缩略图');
            context.createThumbnail(series, firstImage);
          } else {
            console.warn('无法创建缩略图：图像加载失败或缺少创建缩略图功能');
            if (context.createPlaceholderThumbnail) {
              context.createPlaceholderThumbnail(series);
            }
          }
        } else {
          console.warn('跳过缩略图创建：图像ID列表为空或缺少加载函数');
          if (context.createPlaceholderThumbnail) {
            context.createPlaceholderThumbnail(series);
          }
        }
      } catch (error) {
        console.error('加载首张图像失败:', error);
        if (context.createPlaceholderThumbnail) {
          context.createPlaceholderThumbnail(series);
        }
      }
      
      // 启用预加载功能并更新加载进度
      if (context.preloadImagesWithProgress) {
        context.preloadImagesWithProgress(result.imageIds, series);
      }
      
      // 加载完成后更新状态
      if (context.setSeriesLoading) {
        context.setSeriesLoading(series, false);
      }
      
      return true;
    } else {
      console.error(result.error);
      
      if (context.setSeriesLoading) {
        context.setSeriesLoading(series, false);
      }
      
      // 显示错误信息
      if (context.setError) {
        context.setError(result.error);
      }
      
      return false;
    }
  } catch (error) {
    console.error('加载序列失败:', error);
    
    if (context.setSeriesLoading) {
      context.setSeriesLoading(series, false);
    }
    
    // 显示错误信息
    if (context.setError) {
      context.setError('加载序列失败: ' + (error.message || '未知错误'));
    }
    
    return false;
  }
}

/**
 * 加载并显示图像
 * @param {string} imageId - 图像ID
 * @param {HTMLElement} viewportElement - 视口元素
 * @param {Object} context - 上下文对象，包含设置状态的回调
 * @returns {Promise<Object>} 加载的图像对象
 */
export async function loadAndDisplayImage(imageId, viewportElement, context) {
  if (!imageId) return null;
  
  try {
    // 调用viewerService加载并显示图像
    const image = await viewerService.loadAndDisplayImage(imageId, viewportElement);
    
    // 更新当前图像信息
    if (context.updateImageMetadata && context.currentImageIndex !== undefined) {
      context.updateImageMetadata(context.currentImageIndex);
    }
    
    return image;
  } catch (error) {
    console.error('加载图像失败:', error);
    return null;
  }
}

/**
 * 显示指定索引的图像
 * @param {number} imageIndex - 图像索引
 * @param {Object} context - 上下文对象，包含需要的状态和回调
 * @returns {Promise<boolean>} 显示成功返回true
 */
export async function displayImage(imageIndex, context) {
  const { imageIds, viewportElement, updateImageMetadata } = context;
  
  if (!imageIds || imageIndex < 0 || imageIndex >= imageIds.length) {
    return false;
  }
  
  // 如果已经在加载中且请求的是不同图像，取消当前操作
  if (context.imageLoading && context._lastRequestedIndex === imageIndex) {
    return false;
  }
  
  // 记录当前请求的索引
  context._lastRequestedIndex = imageIndex;
  
  try {
    // 更新当前索引
    if (context.setCurrentImageIndex) {
      context.setCurrentImageIndex(imageIndex);
    }
    
    // 获取图像ID
    const imageId = imageIds[imageIndex];
    
    // 显示加载状态
    context.imageLoading = true;
    
    // 使用viewportService显示图像
    const result = await viewportService.displayImage(imageId, viewportElement);
    
    if (!result.success) {
      console.error('显示图像失败:', result.error);
      context.imageLoading = false;
      return false;
    }
    
    // 如果在加载过程中又请求了新图像，则放弃当前操作
    if (context._lastRequestedIndex !== imageIndex) {
      return false;
    }
    
    // 更新图像元数据
    if (updateImageMetadata) {
      updateImageMetadata(imageIndex);
    }
    
    // 关闭加载状态
    context.imageLoading = false;
    
    // 只在开发环境输出性能日志
    if (process.env.NODE_ENV === 'development') {
      const displayTime = result.displayTime;
      if (displayTime > 100) { // 只记录较慢的显示操作
        console.log(`图像 ${imageIndex + 1}/${imageIds.length} 显示耗时: ${displayTime.toFixed(2)}ms`);
      }
    }
    
    // 预加载相邻图像
    if (context.preloadAdjacentImages) {
      context.preloadAdjacentImages(imageIndex, imageIds);
    }
    
    return true;
  } catch (error) {
    console.error('显示图像失败:', error);
    context.imageLoading = false;
    return false;
  }
}

export default {
  loadPatientStudies,
  loadStudy,
  loadSeries,
  loadAndDisplayImage,
  displayImage
} 